package com.honghe.system.service.impl;

import java.util.List;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.honghe.system.mapper.BankCustomerCasesMapper;
import com.honghe.system.domain.BankCustomerCases;
import com.honghe.system.service.IBankCustomerCasesService;
import com.honghe.common.utils.SecurityUtils;
import com.honghe.common.core.domain.model.LoginUser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 客户信息Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-04-13
 */
@Service
public class BankCustomerCasesServiceImpl implements IBankCustomerCasesService 
{
    private static final Logger logger = LoggerFactory.getLogger(BankCustomerCasesServiceImpl.class);

    @Autowired
    private BankCustomerCasesMapper bankCustomerCasesMapper;

    /**
     * 查询客户信息
     * 
     * @param caseId 客户信息主键
     * @return 客户信息
     */
    @Override
    public BankCustomerCases selectBankCustomerCasesByCaseId(Long caseId)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        BankCustomerCases cases = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(caseId);
        
        // 如果不是系统管理员，则需要验证权限
        if (cases != null && loginUser != null && !SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
            // 拥有system:cases:handler权限的用户可以查看任意客户信息
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以查看任意客户信息", loginUser.getUsername());
                return cases;
            }
            
            // 原有逻辑：如果既不是案件负责人也不是经办人，返回null
            if (!loginUser.getUsername().equals(cases.getCaseHandler())
                && !loginUser.getUsername().equals(cases.getHandlerUser())) {
                return null;
            }
        }
        return cases;
    }

    /**
     * 查询客户信息列表
     * 
     * @param bankCustomerCases 客户信息
     * @return 客户信息
     */
    @Override
    public List<BankCustomerCases> selectBankCustomerCasesList(BankCustomerCases bankCustomerCases)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            // 拥有system:cases:handler权限的用户可以查看所有客户案件
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以查看所有客户信息列表", loginUser.getUsername());
                // 不添加数据权限过滤，可以查看所有数据
            }
            // 如果有case_manager权限且不具有system:cases:handler权限，则按原有规则处理
            else if (loginUser.getPermissions().contains("system:cases:case_manager")) {
                // 设置数据权限过滤条件
                Map<String, Object> params = bankCustomerCases.getParams() != null ? 
                    (Map<String, Object>) bankCustomerCases.getParams() : new HashMap<>();
                
                // 只能查看自己负责或经办的案件
                params.put("dataScope", "(" +
                    "case_handler = '" + loginUser.getUsername() + "' " +
                    "OR handler_user = '" + loginUser.getUsername() + "'" +
                    ")");
                
                bankCustomerCases.setParams(params);
                logger.info("用户[{}]查询客户列表，添加数据权限过滤", loginUser.getUsername());
            }
        }
        
        return bankCustomerCasesMapper.selectBankCustomerCasesList(bankCustomerCases);
    }

    /**
     * 查询公海池客户数量
     * 
     * @return 客户数量
     */
    @Override
    public List<Map<String, Object>> selectPoolCounts()
    {
        BankCustomerCases bankCustomerCases = new BankCustomerCases();
        // 设置数据权限
        Map<String, Object> params = new HashMap<>();
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            // 拥有system:cases:handler权限的用户可以查看所有公海池数据
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以查看所有公海池数据", loginUser.getUsername());
                params.put("dataScope", "1=1");
            }
            // 如果不是系统管理员且不拥有system:cases:handler权限
            else if (!SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
                // 只能查看自己负责或经办的案件
                params.put("dataScope", "(" +
                    "case_handler = '" + loginUser.getUsername() + "' " +
                    "OR handler_user = '" + loginUser.getUsername() + "'" +
                    ")");
            } else {
                params.put("dataScope", "1=1");
            }
            params.put("username", loginUser.getUsername());
            bankCustomerCases.setParams(params);
        }
        return bankCustomerCasesMapper.selectPoolCounts(bankCustomerCases);
    }

    /**
     * 获取时间段内新增客户统计
     */
    @Override
    public List<Map<String, Object>> selectNewCustomerStats(String beginTime, String endTime, String poolType)
    {
        Map<String, Object> params = new HashMap<>();
        params.put("beginTime", beginTime);
        params.put("endTime", endTime);
        params.put("poolType", poolType);
        
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            // 拥有system:cases:handler权限的用户可以查看所有客户统计数据
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以查看所有客户统计数据", loginUser.getUsername());
                // 不添加数据权限过滤
            }
            // 如果不是系统管理员且不拥有system:cases:handler权限
            else if (!SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
                // 只能查看自己负责或经办的案件
                params.put("dataScope", "(" +
                    "case_handler = '" + loginUser.getUsername() + "' " +
                    "OR handler_user = '" + loginUser.getUsername() + "'" +
                    ")");
            }
        }
        
        return bankCustomerCasesMapper.selectNewCustomerStats(params);
    }

    /**
     * 新增客户信息
     * 
     * @param bankCustomerCases 客户信息
     * @return 结果
     */
    @Override
    public int insertBankCustomerCases(BankCustomerCases bankCustomerCases)
    {
        // 不再自动设置默认经办人和负责人，使用用户提交的值
        return bankCustomerCasesMapper.insertBankCustomerCases(bankCustomerCases);
    }

    /**
     * 修改客户信息
     * 
     * @param bankCustomerCases 客户信息
     * @return 结果
     */
    @Override
    public int updateBankCustomerCases(BankCustomerCases bankCustomerCases)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null) {
            // 检查用户是否拥有system:cases:handler权限，如果有，则允许修改任意客户信息
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                // 拥有system:cases:handler权限的用户可以修改任意客户信息，不受限制
                logger.info("用户[{}]拥有system:cases:handler权限，可以修改任意客户信息", loginUser.getUsername());
                return bankCustomerCasesMapper.updateBankCustomerCases(bankCustomerCases);
            }
            
            // 其他逻辑保持不变
            // 如果不是系统管理员
            if (!SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
                // 获取原始案件信息
                BankCustomerCases original = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(Long.valueOf(bankCustomerCases.getCaseId()));
                if (original != null) {
                    // 如果当前用户既不是案件负责人也不是经办人，不能修改
                    if (!loginUser.getUsername().equals(original.getCaseHandler()) 
                        && !loginUser.getUsername().equals(original.getHandlerUser())) {
                        return 0;
                    }
                    
                    // 允许拥有system:cases:case_manager权限的用户（案件负责人或经办人）任意修改案件负责人和经办人
                    if (loginUser.getPermissions().contains("system:cases:case_manager")) {
                        logger.info("用户[{}]拥有system:cases:case_manager权限且是案件负责人或经办人，可以修改案件负责人和经办人", loginUser.getUsername());
                    } else {
                        // 只有系统管理员或原案件负责人可以修改案件负责人
                        if (!loginUser.getUsername().equals(original.getCaseHandler())) {
                            bankCustomerCases.setCaseHandler(original.getCaseHandler());
                        }
                        
                        // 只有系统管理员或案件负责人可以修改经办人
                        if (!loginUser.getUsername().equals(original.getCaseHandler())) {
                            bankCustomerCases.setHandlerUser(original.getHandlerUser());
                        }
                    }
                }
            }
        }
        return bankCustomerCasesMapper.updateBankCustomerCases(bankCustomerCases);
    }

    /**
     * 批量删除客户信息
     * 
     * @param caseIds 需要删除的客户信息主键
     * @return 结果
     */
    @Override
    public int deleteBankCustomerCasesByCaseIds(Long[] caseIds)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null && !SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
            // 拥有system:cases:handler权限的用户可以删除任意客户信息
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以删除任意客户信息", loginUser.getUsername());
                return bankCustomerCasesMapper.deleteBankCustomerCasesByCaseIds(caseIds);
            }
            
            // 检查用户是否是所有要删除客户的负责人
            for (Long id : caseIds) {
                BankCustomerCases cases = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(id);
                if (cases == null || !loginUser.getUsername().equals(cases.getCaseHandler())) {
                    return 0;
                }
            }
        }
        return bankCustomerCasesMapper.deleteBankCustomerCasesByCaseIds(caseIds);
    }

    /**
     * 删除客户信息
     * 
     * @param caseId 客户信息主键
     * @return 结果
     */
    @Override
    public int deleteBankCustomerCasesByCaseId(Long caseId)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null && !SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
            // 拥有system:cases:handler权限的用户可以删除任意客户信息
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以删除任意客户信息", loginUser.getUsername());
                return bankCustomerCasesMapper.deleteBankCustomerCasesByCaseId(caseId);
            }
            
            // 检查用户是否是要删除客户的负责人
            BankCustomerCases cases = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(caseId);
            if (cases == null || !loginUser.getUsername().equals(cases.getCaseHandler())) {
                return 0;
            }
        }
        return bankCustomerCasesMapper.deleteBankCustomerCasesByCaseId(caseId);
    }

    /**
     * 分配客户到指定经办人
     * 
     * @param ids 客户ID数组
     * @param handlerUser 经办人
     * @param updateBy 更新者
     * @return 结果
     */
    @Override
    public int assignCases(Long[] ids, String handlerUser, String updateBy)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null && !SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
            // 拥有system:cases:handler权限的用户可以分配任意客户案件
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以分配任意客户案件", loginUser.getUsername());
            } else {
                boolean hasCaseManagerPermi = loginUser.getPermissions().contains("system:cases:case_manager");
                // 检查是否是案件负责人或经办人（如果有case_manager权限）
                for (Long id : ids) {
                    BankCustomerCases cases = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(id);
                    if (cases == null) {
                        return 0;
                    }
                    
                    // 如果有case_manager权限且是案件负责人或经办人，可以任意分配
                    if (hasCaseManagerPermi && 
                        (loginUser.getUsername().equals(cases.getCaseHandler()) || 
                         loginUser.getUsername().equals(cases.getHandlerUser()))) {
                        logger.info("用户[{}]拥有system:cases:case_manager权限且是案件负责人或经办人，可以分配客户到任意经办人", loginUser.getUsername());
                        continue; // 继续检查下一个案件
                    }
                    
                    // 否则仅负责人可以分配
                    if (!loginUser.getUsername().equals(cases.getCaseHandler())) {
                        return 0;
                    }
                }
            }
        }
        
        Map<String, Object> params = new HashMap<>();
        params.put("ids", ids);
        params.put("handlerUser", handlerUser);
        params.put("poolType", null); // 分配经办人时清除公海池类型
        params.put("updateBy", updateBy);
        return bankCustomerCasesMapper.updateCasesPool(params);
    }

    /**
     * 更新客户池类型
     * 
     * @param ids 客户ID数组
     * @param poolType 池类型
     * @param caseHandler 案件负责人
     * @param handlerUser 经办人
     * @param updateBy 更新者
     * @return 结果
     */
    @Override
    public int updateCasesPool(Long[] ids, String poolType, String caseHandler, String handlerUser, String updateBy)
    {
        // 获取当前登录用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (loginUser != null && !SecurityUtils.isAdmin(loginUser.getUser().getUserId())) {
            // 拥有system:cases:handler权限的用户可以更新任意客户的公海池信息
            if (loginUser.getPermissions().contains("system:cases:handler")) {
                logger.info("用户[{}]拥有system:cases:handler权限，可以更新任意客户的公海池信息", loginUser.getUsername());
            } else {
                boolean hasCaseManagerPermi = loginUser.getPermissions().contains("system:cases:case_manager");
                // 检查是否是案件负责人或经办人
                for (Long id : ids) {
                    BankCustomerCases cases = bankCustomerCasesMapper.selectBankCustomerCasesByCaseId(id);
                    if (cases == null) {
                        return 0;
                    }
                    
                    boolean isHandler = loginUser.getUsername().equals(cases.getCaseHandler());
                    boolean isAssignee = loginUser.getUsername().equals(cases.getHandlerUser());
                    
                    // 如果有case_manager权限且是案件负责人或经办人，可以任意更新公海池
                    if (hasCaseManagerPermi && (isHandler || isAssignee)) {
                        logger.info("用户[{}]拥有system:cases:case_manager权限且是案件负责人或经办人，可以更新公海池信息", loginUser.getUsername());
                        continue; // 继续检查下一个案件
                    }
                    
                    // 否则按原规则检查
                    if (!isHandler && !isAssignee) {
                        return 0;
                    }
                }
            }
        }
        
        Map<String, Object> params = new HashMap<>();
        params.put("ids", ids);
        params.put("poolType", poolType);
        params.put("caseHandler", caseHandler);
        params.put("handlerUser", handlerUser);
        params.put("updateBy", updateBy);
        return bankCustomerCasesMapper.updateCasesPool(params);
    }
    
    /**
     * 更新客户池类型
     * 
     * @param ids 客户ID数组
     * @param poolType 池类型
     * @param updateBy 更新者
     * @return 结果
     */
    @Override
    public int updateCasesPool(Long[] ids, String poolType, String updateBy)
    {
        // 调用重载方法，保持负责人和经办人不变
        return updateCasesPool(ids, poolType, null, null, updateBy);
    }
}
